import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

class position {
    int x;
    int y;
    int lever;
    public position(int x, int y, int lever) {
        this.x = x;
        this.y = y;
        this.lever = lever;
    }
    public position(){}
}
public class demo {
    // 解读密码
//nowcoder要和朋友交流一些敏感的信息，例如他的电话号码等。因此他要对这些敏感信息进行混淆，比如在数字中间掺入一些额外的符号，
//让它看起来像一堆乱码。现在请你帮忙开发一款程序，解析从nowcoder那儿接收到的信息，读取出中间有用的信息。
//        输入描述:
//      输入有多行。
//      每一行有一段经过加密的信息（其中可能包含空格），并且原始信息长度不确定。
//        输出描述:
//      输出每段信息中数字信息。
//        输入
//      $Ts!47&*s456  a23* +B9k
//        输出
//      47456239
    public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String str = sc.nextLine();
            StringBuffer sb = new StringBuffer();
            for (int i=0; i<str.length(); i++) {
                if (str.charAt(i)>='0' && str.charAt(i)<='9') {
                    sb.append(str.charAt(i));
                }
            }
            System.out.println(sb);
        }
    }




    // 走迷宫▲▲▲▲▲
//NowCoder最喜欢游乐场的迷宫游戏，他和小伙伴们比赛谁先走出迷宫。现在把迷宫的地图给你，你能帮他算出最快走出迷宫需要多少步吗？
//    输入描述:
//  输入包含多组数据。
//  每组数据包含一个10*10，由“#”和“.”组成的迷宫。其中“#”代表墙；“.”代表通路。
//  入口在 第一行第二列；出口 在最后一行第九列。
//  从任意一个“.”点都能一步走到上下左右四个方向的“.”点。
//    输出描述:
//  对应每组数据，输出从入口到出口最短需要几步。
//
//#.########
//#........#
//#........#
//#........#
//#........#
//#........#
//#........#
//#........#
//#........#
//########.#
//    16

//    思路:
//  采用二维数组保存地图数据，如下图所示，'#'代表墙，' . ' 代表通路，在每个路口时，可以向上下
//左右4个方向移动(除过边界)，当一条路径不通时，需要回溯到上一步，回溯到上一个路口后再向
//其他方向探索，直到走到出口，一条路径找到，求解出步数，再回退找其他路径，求解出最短的
//路径。以上方式是采用深度优先方式遍历，但是深度优先方式找到一条路径后，该路径不一定是
//最短路径，需要将所有路径找到后比较，才能确定出最终的最短路径。
//  该题最佳的解决方式是：采用广度优先遍历，即一层一层的往下移动△△△△(可参考图的广度优先遍历思
//想)，采用广度优先方式遍历，当找到出口时，则为最短路径。大概方式：在一个位置时，计算该
//位置上、下、左、右四个方向，如果该位置在出口即找到，否则检测该位置是否有效且为通路，
//如果是将其保存到队列中，再继续该过程，直到找到出口，具体参考解题思路。


    //    class position {
//    int x;
//    int y;
//    int lever;
//          public position(int x, int y, int lever) {
//              this.x = x;
//              this.y = y;
//              this.lever = lever;
//          }
//          public position(){}
//    }
    static final int N = 10;
    // 广度优先遍历 找最短距离
    public static int bfs(char[][] map, int n, int m) {
        int[][] direct = {//通过 下右左上依次遍历
                {1,0},
                {0,1},
                {0,-1},
                {-1,0}
        };

        // 入口
        position enter = new position(0, 1, 0);
        // 出口
        position out = new position(9, 8, 0);

        // 广度优先遍历 利用队列来完成
        Queue<position> queue = new LinkedList<>();
        queue.add(enter);

        // 保存其他方向的位置 和到该方向的步数
        position next = new position();

        // 标记 表示该位置是否走过
        boolean[][] flag = new boolean[n][m];

        while (!queue.isEmpty()) {
            // 取出队列第一个 并且加入队列中满足条件的4个方向的位置
            position cur = queue.poll();

            // 循环的结束条件就是到达出口位置
            if (cur.x==out.x && cur.y==out.y) {
                return cur.lever;
            }
            // 走过该点 标记为true     默认是false没有走过
            flag[cur.x][cur.y] = true;
            for (int i=0; i<4; i++)  {
                next.x = cur.x + direct[i][0];
                next.y = cur.y + direct[i][1];
                // 如果下一方向点(上下左右) 满足
                // 没越界 没走过 是通路
                // 就加入到队列中(记得路径要+1) 是cur.lever+1
                if (next.x>=0 && next.x<n && next.y>=0 && next.y<m &&
                        !flag[next.x][next.y] &&
                        map[next.x][next.y]=='.') {
                    queue.add(new position(next.x, next.y, cur.lever+1));
                }
            }
        }
        // 走到这 队列中为空 表示没有该出口
        return 0;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            // 获取地图数据
            char[][] map = new char[N][N];
            for (int i=0; i<N; i++) {
                String str = sc.next();
                for (int j=0; j<N; j++) {
                    map[i][j] = str.charAt(j);
                }
            }
            // 进行广度优先遍历 寻找最短路径
            int count = bfs(map, N, N);
            System.out.println(count);
        }
    }
}

